#include <stdio.h>
#include <string.h>
#include <unistd.h>

#include "lwip/api_shell.h"
#include "lwip/ip4_addr.h"
#include "lwip/netif.h"
#include "lwip/netifapi.h"

#include "iot_gpio.h"
#include "cmsis_os2.h"
#include "ohos_init.h"
#include "wifi_device.h"
#include "wifi_error_code.h"
#include <sys/time.h>
#include "ssd1306.h"  // 添加SSD1306头文件引用
#include "dht11.h"    // 添加DHT11头文件引用


// 前置声明
static int WiFiInit(void);
static void WaitSacnResult(void);
static int WaitConnectResult(void);
static void OnWifiScanStateChangedHandler(int state, int size);
static void OnWifiConnectionChangedHandler(int state, WifiLinkedInfo *info);
static void OnHotspotStaJoinHandler(StationInfo *info);
static void OnHotspotStateChangedHandler(int state);
static void OnHotspotStaLeaveHandler(StationInfo *info);
static time_t get_adjusted_time(time_t *t);


/*
 * WiFi STA模式连接示例 - 实现设备通过STA模式连接指定WiFi热点
 * 主要功能：
 * 1. 初始化WiFi模块
 * 2. 扫描周围WiFi热点
 * 3. 连接指定SSID的热点
 * 4. 获取并显示IP地址
 */


// 定义任务参数
#define TASK_STACK_SIZE (1024 * 10)  // 任务栈大小
#define TASK_PRIO 24                 // 任务优先级
#define DEF_TIMEOUT 15               // 默认超时时间(秒)
#define ONE_SECOND 1                 // 1秒延时单位
#define DHCP_DELAY 100               // DHCP检查间隔(ms)

#define TASK_DELAY_2S 2 //  定义任务延迟时间为2秒
#define CONFIG_CLIENT_PORT 8888      // 要连接的服务器端口
#define TCP_BACKLOG 10

// 添加SW-520D角度倾斜模块的GPIO引脚定义
#define SW520D_GPIO_PIN 5  // 使用GPIO5连接SW-520D模块，您可以根据实际连接修改

// 添加DHT11温湿度传感器的GPIO引脚定义
#define DHT11_GPIO_PIN 7  // 修改为GPIO7连接DHT11模块，请根据实际连接修改

// 添加LED引脚定义
#define LED1_PIN 11  // LED1引脚
#define LED2_PIN 2   // LED2引脚
#define BUZZER_PIN 4 // 蜂鸣器引脚


// 定义默认连接参数
#define SELECT_WLAN_PORT "wlan0"     // 使用的网络接口
#define SELECT_WIFI_SSID "HONOR 200"    // 默认连接SSID
#define SELECT_WIFI_PASSWORD "20050126" // 默认密码
//#define SELECT_WIFI_SSID "秦王阁"    // 默认连接SSID
//#define SELECT_WIFI_PASSWORD "cxg33366888" // 默认密码
#define SELECT_WIFI_SECURITYTYPE WIFI_SEC_TYPE_PSK // 加密类型
#define sntp_idx 1                    // NTP服务器索引
#define sntp_address "121.199.69.55" // NTP服务器ip地址
#define sntp_address_name "ntp1.aliyun.com" // NTP服务器域名
#define SNTP_SERVER_DNS 1             // 启用DNS解析NTP服务器主机名
#define SNTP_GET_SERVERS_FROM_DHCP 1  // 从DHCP获取NTP服务器地址


// 全局状态变量
static int g_staScanSuccess = 0;     // 扫描成功标志
static int g_connectSuccess = 0;     // 连接成功标志
static int g_ssid_count = 0;         // 扫描到的SSID数量
static struct netif *g_lwip_netif = NULL; // 网络接口指针
static WifiEvent g_wifiEventHandler = { 0 }; // WiFi事件回调
WifiErrorCode error;                  // 

// 添加全局变量
static int g_ledHour = 12;    // 默认12点（用户设定时间
static int g_ledMin = 0;      // 默认0分
static int g_ledEnable = 0;   // 定时功能默认关闭

// 添加第二个闹钟全局变量
static int g_ledHour2 = 12;    // 第二个闹钟默认12点
static int g_ledMin2 = 30;     // 第二个闹钟默认30分
static int g_ledEnable2 = 0;   // 第二个闹钟默认关闭

// 添加查找功能全局变量
static int g_findMode = 0;     // 查找模式标志：0-关闭，1-开启
static int g_findBlinkSpeed = 1; // 查找模式闪烁速度：1-慢速，2-中速，3-快速

// 添加RTC初始化状态变量
int rtc_init_success = 0;   // 0:未初始化 1:软件I2C模式初始化成功

// 添加DHT11温湿度数据全局变量
static float g_temperature = 0.0;  // 温度
static float g_humidity = 0.0;     // 湿度
static int g_dht11_error_count = 0; // DHT11读取错误计数

/*
static int g_ledHour_2 = 12;    // 默认12点（用户设定时间
static int g_ledMin_2 = 0;      // 默认0分
static int g_ledEnable = 0;   // 定时功能默认关闭

static int g_ledHour_3 = 12;    // 默认12点（用户设定时间
static int g_ledMin = 0;      // 默认0分
static int g_ledEnable = 0;   // 定时功能默认关闭
*/

// 在全局变量区域添加
static time_t g_last_sync_time = 0;  // 上次同步时间戳
static time_t g_time_offset = 0;     // 本地时间与网络时间的偏移量
static int g_first_dht11_read = 1;   // 首次DHT11读取标志
static int g_run_dht11_test = 1;     // 是否运行DHT11测试



char recvbuf[512];
char *buf = "Hello! I'm BearPi-HM_Nano TCP Server!"; // 发送数据

/**
 * @brief 连接指定WiFi热点
 * @param ssid 目标SSID
 * @param psk 连接密码
 * @param info 扫描结果数组
 * @param i 当前处理的扫描结果索引
 * @return 0成功 -1失败
 */

static int WifiConnectAp(const char *ssid, const char *psk, WifiScanInfo *info, int i)
{
    // 检查是否匹配目标SSID
    if (strcmp(ssid, info[i].ssid) == 0) {
        int result;
        printf("正在连接第%3d个无线网络...\r\n", i + 1);

        // 配置连接参数
        WifiDeviceConfig select_ap_config = { 0 };
        strcpy_s(select_ap_config.ssid, sizeof(select_ap_config.ssid), info[i].ssid);
        strcpy_s(select_ap_config.preSharedKey, sizeof(select_ap_config.preSharedKey), psk);
        select_ap_config.securityType = WIFI_SEC_TYPE_PSK;

        // 添加配置并连接
        if (AddDeviceConfig(&select_ap_config, &result) == WIFI_SUCCESS) {
            if (ConnectTo(result) == WIFI_SUCCESS && WaitConnectResult() == 1) {
                g_lwip_netif = netifapi_netif_find(SELECT_WLAN_PORT);
                return 0;
            }
        }
    }
    return -1;
}

/**
 * @brief WiFi STA模式主任务
 * 1. 初始化WiFi
 * 2. 扫描热点
 * 3. 连接指定热点
 * 4. 获取IP地址
 */

static BOOL WifiStaTask(void)
{
    unsigned int size = WIFI_SCAN_HOTSPOT_LIMIT;

    // 初始化WiFi模块
    if (WiFiInit() != WIFI_SUCCESS) {
        printf("WiFi初始化失败, 错误码 = %d\r\n", error);
        return -1;
    }
    
    // 分配扫描结果存储空间
    WifiScanInfo *info = malloc(sizeof(WifiScanInfo) * WIFI_SCAN_HOTSPOT_LIMIT);
    if (info == NULL) {
        return -1;
    }
    
    // 扫描WiFi网络
    do {
        Scan();
        WaitSacnResult();
        error = GetScanInfoList(info, &size);
    } while (g_staScanSuccess != 1);
    
    // 打印扫描结果
    printf("****** 可用的WiFi网络 ******\r\n");
    for (uint8_t i = 0; i < g_ssid_count; i++) {
        printf("编号:%03d, SSID:%-30s, 信号强度:%5d\r\n", i + 1, info[i].ssid, info[i].rssi);
    }
    printf("***************************\r\n");
    
    // 尝试连接指定WiFi
    for (uint8_t i = 0; i < g_ssid_count; i++) {
        if (WifiConnectAp(SELECT_WIFI_SSID, SELECT_WIFI_PASSWORD, info, i) == WIFI_SUCCESS) {
            printf("WiFi连接成功!\r\n");
            break;
        }

        if (i == g_ssid_count - 1) {
            printf("错误: 未找到指定WiFi网络\r\n");
            while (1)
                osDelay(DHCP_DELAY);
        }
    }

    // DHCP获取IP地址
    if (g_lwip_netif) {
        dhcp_start(g_lwip_netif);
        printf("开始获取IP地址...\r\n");
    }
    
    // 等待DHCP完成
    for (;;) {
        if (dhcp_is_bound(g_lwip_netif) == ERR_OK) {
            printf("<-- DHCP状态:成功 -->\n");
            netifapi_netif_common(g_lwip_netif, dhcp_clients_info_show, NULL);
            
            
            // 显示当前时间
            time_t now;
            struct tm *timeinfo;
            time(&now);
            timeinfo = localtime(&now);
            printf("当前时间: %04d-%02d-%02d %02d:%02d:%02d\n",
                  timeinfo->tm_year + 1900, timeinfo->tm_mon + 1, timeinfo->tm_mday,
                  timeinfo->tm_hour, timeinfo->tm_min, timeinfo->tm_sec);
            
            break;
        }
        osDelay(DHCP_DELAY);
    }

    // 任务完成，退出
    return TRUE;
}

int WiFiInit(void)
{
    // 设置WiFi事件回调函数
    g_wifiEventHandler.OnWifiScanStateChanged = OnWifiScanStateChangedHandler;
    g_wifiEventHandler.OnWifiConnectionChanged = OnWifiConnectionChangedHandler;
    g_wifiEventHandler.OnHotspotStaJoin = OnHotspotStaJoinHandler;
    g_wifiEventHandler.OnHotspotStaLeave = OnHotspotStaLeaveHandler;
    g_wifiEventHandler.OnHotspotStateChanged = OnHotspotStateChangedHandler;

    // 注册WiFi事件处理函数
    error = RegisterWifiEvent(&g_wifiEventHandler);
    if (error != WIFI_SUCCESS) {
        printf("注册WiFi事件失败! 错误码: 0x%X\n", error);
        printf("可能原因:\n");
        printf("1. WiFi服务未启动\n");
        printf("2. 内存不足\n");
        printf("3. 事件回调函数未正确设置\n");
        return -1;
    }
    
    // 使能WIFI
    if (EnableWifi() != WIFI_SUCCESS) {
        printf("EnableWifi failed, error = %d\r\n", error);
        return -1;
    }
    // 判断WIFI是否激活
    if (IsWifiActive() == 0) {
        printf("Wifi station is not actived.\r\n");
        return -1;
    }
    return 0;
}

// 定义一个静态函数，用于处理WiFi扫描状态变化的回调
static void OnWifiScanStateChangedHandler(int state, int size)
{
    // 使用(void)来显式忽略state参数，表示该参数在函数内部不会被使用
    (void)state;
    // 检查扫描结果的大小是否大于0，即是否有可用的WiFi网络
    if (size > 0) {
        // 如果有可用的网络，将全局变量g_ssid_count设置为size，表示可用网络的数量
        g_ssid_count = size;
        // 将全局变量g_staScanSuccess设置为1，表示扫描成功
        g_staScanSuccess = 1;
    }
    // 函数执行完毕，返回
    return;
}

// 定义一个静态函数，用于处理WiFi连接状态变化的回调
static void OnWifiConnectionChangedHandler(int state, WifiLinkedInfo *info)
{
    // 使用(void)info来明确表示info参数在函数内部未被使用，避免编译器警告
    (void)info;

    // 检查连接状态，如果state大于0，表示连接成功
    if (state > 0) {
        // 设置全局变量g_connectSuccess为1，表示连接成功
        g_connectSuccess = 1;
        // 打印连接成功的回调信息
        printf("callback function for wifi connect\r\n");
    } else {
        // 如果连接失败，打印错误信息，提示检查密码
        printf("connect error,please check password\r\n");
    }
    // 函数结束，返回
    return;
}

// 定义一个静态函数 OnHotspotStaJoinHandler，用于处理热点中设备（STA）加入的事件
// 参数 StationInfo *info 是指向包含设备信息的结构体的指针
static void OnHotspotStaJoinHandler(StationInfo *info)
{
    // 使用 (void)info; 将 info 参数显式转换为 void 类型，表示该参数在函数内部未被使用
    (void)info;
    // 使用 printf 函数输出一条消息到控制台，表示有一个设备（STA）加入了热点（AP）
    printf("STA join AP\n");
    // 函数执行完毕，返回。由于是 void 函数，不需要返回值
    return;
}

// 定义一个静态函数 OnHotspotStaLeaveHandler，用于处理热点中的站点离开事件
// 参数 StationInfo *info 指向站点信息的结构体
static void OnHotspotStaLeaveHandler(StationInfo *info)
{
    // 使用 (void)info; 将 info 参数显式转换为 void 类型，表示忽略该参数
    // 这通常用于避免编译器警告，因为该参数在函数体内没有被使用
    (void)info;
    // 使用 printf 函数输出一条信息到标准输出
    // 信息内容为 "HotspotStaLeave:info is null.\n"
    // 表示热点中的站点离开时，站点信息为空
    printf("HotspotStaLeave:info is null.\n");
    // 函数执行完毕，返回
    return;
}

// 定义一个静态函数，用于处理热点状态变化的回调
static void OnHotspotStateChangedHandler(int state)
{
    printf("HotspotStateChanged:state is %d.\n", state);
    // 函数执行完毕后返回，由于是void类型函数，不需要返回值
    return;
}

// 定义一个静态函数 WaitSacnResult，用于等待扫描结果
static void WaitSacnResult(void)
{
    // 定义一个整型变量 scanTimeout，并初始化为预定义的超时时间 DEF_TIMEOUT
    int scanTimeout = DEF_TIMEOUT;
    // 使用 while 循环，当 scanTimeout 大于 0 时继续循环
    while (scanTimeout > 0) {
        // 调用 sleep 函数，暂停程序执行 ONE_SECOND 秒
        sleep(ONE_SECOND);
        // 将 scanTimeout 减 1，减少剩余等待时间
        scanTimeout--;
        // 检查全局变量 g_staScanSuccess 是否等于 1，表示扫描成功
        if (g_staScanSuccess == 1) {
            // 如果扫描成功，打印等待成功的信息，并显示等待了多长时间
            printf("WaitSacnResult:wait success[%d]s\n", (DEF_TIMEOUT - scanTimeout));
            // 使用 break 语句跳出 while 循环
            break;
        }
    }
    // 如果循环结束后 scanTimeout 小于等于 0，表示等待超时
    if (scanTimeout <= 0) {
        // 打印超时信息
        printf("WaitSacnResult:timeout!\n");
    }
}

static int WaitConnectResult(void)
{
    int ConnectTimeout = DEF_TIMEOUT;
    while (ConnectTimeout > 0) {
        sleep(1);
        ConnectTimeout--;
        if (g_connectSuccess == 1) {
            printf("WaitConnectResult:wait success[%d]s\n", (DEF_TIMEOUT - ConnectTimeout));
            break;
        }
    }
    if (ConnectTimeout <= 0) {
        printf("WaitConnectResult:timeout!\n");
        return 0;
    }

    return 1;
}

// 定义一个静态函数 WifiClientSTA，用于创建 WiFi STA 任务
static void WifiClientSTA(void)
{
    // 定义一个 osThreadAttr_t 类型的结构体变量 attr，用于配置线程属性
    osThreadAttr_t attr;

    // 设置线程名称为 "WifiStaTask"
    attr.name = "WifiStaTask";
    // 设置线程属性位为 0U，表示没有特殊的线程属性
    attr.attr_bits = 0U;
    // 设置线程控制块的内存指针为 NULL，表示使用默认的内存管理
    attr.cb_mem = NULL;
    // 设置线程控制块的大小为 0U，表示使用默认的大小
    attr.cb_size = 0U;
    // 设置线程堆栈的内存指针为 NULL，表示使用默认的堆栈内存管理
    attr.stack_mem = NULL;
    // 设置线程堆栈的大小为 TASK_STACK_SIZE，表示使用定义的堆栈大小
    attr.stack_size = TASK_STACK_SIZE;
    // 设置线程的优先级为 TASK_PRIO，表示使用定义的优先级
    attr.priority = TASK_PRIO;

    // 创建一个新的线程，传入线程函数 WifiStaTask，参数为 NULL，属性为 attr
    // 如果创建失败（返回值为 NULL），则打印错误信息
    if (osThreadNew((osThreadFunc_t)WifiStaTask, NULL, &attr) == NULL) {
        printf("Failed to create WifiStaTask!\n");
    }
}




// 修改TCPServerTask函数中的数据处理部分
static void TCPServerTask(void)
{
    // 在sock_fd 进行监听，在 new_fd 接收新的链接
    int sock_fd, new_fd;

    // 服务端地址信息
    struct sockaddr_in server_sock;

    // 客户端地址信息
    struct sockaddr_in client_sock, *cli_addr;
    int sin_size;
    int is_connected = 0;  // 客户端连接状态
    int last_send_time = 0;  // 上次发送数据的时间

    // 创建socket
    if ((sock_fd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
        perror("socket is error\r\n");
        return;
    }

    bzero(&server_sock, sizeof(server_sock));
    server_sock.sin_family = AF_INET;
    server_sock.sin_addr.s_addr = htonl(INADDR_ANY);
    server_sock.sin_port = htons(CONFIG_CLIENT_PORT);

    // 调用bind函数绑定socket和地址
    if (bind(sock_fd, (struct sockaddr *)&server_sock, sizeof(struct sockaddr)) == -1) {
        return;
    }

    // 调用listen函数监听(指定port监听)
    if (listen(sock_fd, TCP_BACKLOG) == -1) {
        return;
    }

    printf("开始监听TCP连接，端口: %d\n", CONFIG_CLIENT_PORT);

    // 调用accept函数从队列中
    while (1) {
        sin_size = sizeof(struct sockaddr_in);

        if ((new_fd = accept(sock_fd, (struct sockaddr *)&client_sock, (socklen_t *)&sin_size)) == -1) {
            perror("accept");
            continue;
        }

        // 新增连接信息打印
        printf("[TCP] 客户端连接来自: %s:%d\r\n", 
              inet_ntoa(client_sock.sin_addr), 
              ntohs(client_sock.sin_port));
        
        is_connected = 1;  // 设置连接状态
        last_send_time = 0;  // 重置发送计时器

        cli_addr = malloc(sizeof(struct sockaddr));

        printf("accept addr\r\n");

        if (cli_addr != NULL) {
            int ret;
            if ((ret = memcpy_s(cli_addr, sizeof(struct sockaddr), &client_sock, sizeof(struct sockaddr))) != 0) {
                perror("memcpy is error\r\n");
                return;
            }
        }
        // 处理目标
        ssize_t ret;
        int time_counter = 0;  // 计时器，用于定时发送数据

        while (1) {
            // 每5秒自动发送一次温湿度数据
            if (time_counter % 5 == 0 && time_counter != last_send_time) {
                // 读取最新的温湿度数据
                DHT11_Data_TypeDef dht11_data = DHT11_Read_Data(DHT11_GPIO_PIN);
                
                // 格式化温湿度数据为JSON
                char dht11_str[128];
                
                if (dht11_data.status == 0) {
                    // 更新全局变量
                    g_temperature = dht11_data.temperature;
                    g_humidity = dht11_data.humidity;
                    
                    // 格式化为JSON，包含更多信息
                    snprintf(dht11_str, sizeof(dht11_str), 
                            "{\"type\":\"dht11_data\",\"temperature\":%.1f,\"humidity\":%.1f,\"status\":\"ok\",\"timestamp\":%ld}",
                            g_temperature, g_humidity, (long)time(NULL));
                } else {
                    // 读取失败，返回上次成功读取的数据和错误状态
                    snprintf(dht11_str, sizeof(dht11_str), 
                            "{\"type\":\"dht11_data\",\"temperature\":%.1f,\"humidity\":%.1f,\"status\":\"error\",\"timestamp\":%ld}",
                            g_temperature, g_humidity, (long)time(NULL));
                }
                
                // 发送数据到客户端
                send(new_fd, dht11_str, strlen(dht11_str), 0);
                printf("[TCP] 自动发送温湿度数据: %s\n", dht11_str);
                
                // 更新发送时间
                last_send_time = time_counter;
            }
            
            // 检查是否有来自客户端的数据
            fd_set readfds;
            struct timeval tv;
            
            FD_ZERO(&readfds);
            FD_SET(new_fd, &readfds);
            
            // 设置超时为1秒
            tv.tv_sec = 1;
            tv.tv_usec = 0;
            
            int activity = select(new_fd + 1, &readfds, NULL, NULL, &tv);
            
            if (activity < 0) {
                printf("[TCP] select错误\n");
                break;
            }
            
            // 如果没有数据，继续循环
            if (activity == 0) {
                time_counter++;
                continue;
            }
            
            // 有数据可读
            if (FD_ISSET(new_fd, &readfds)) {
            memset_s(recvbuf, sizeof(recvbuf), 0, sizeof(recvbuf));
            if ((ret = recv(new_fd, recvbuf, sizeof(recvbuf), 0)) == -1) {
                printf("[TCP] 来自 %s 的连接异常\r\n", inet_ntoa(client_sock.sin_addr));
                break;
            }
            if (ret == 0) {
                printf("[TCP] 客户端 %s:%d 主动断开连接\r\n",
                      inet_ntoa(client_sock.sin_addr),
                      ntohs(client_sock.sin_port));
                break;
            }
            
            recvbuf[ret] = '\0';
            printf("[TCP] 收到来自 %s 的数据: %s\r\n", 
                  inet_ntoa(client_sock.sin_addr), 
                  recvbuf);
            
                // 处理客户端请求
                if (strstr(recvbuf, "GET_DHT11") != NULL) {
                    // 客户端请求当前温湿度数据
                    char dht11_str[128];
                    
                    // 读取最新的温湿度数据
                    DHT11_Data_TypeDef dht11_data = DHT11_Read_Data(DHT11_GPIO_PIN);
                    
                    if (dht11_data.status == 0) {
                        // 更新全局变量
                        g_temperature = dht11_data.temperature;
                        g_humidity = dht11_data.humidity;
                        
                        // 格式化温湿度数据为JSON
                        snprintf(dht11_str, sizeof(dht11_str), 
                                "{\"type\":\"dht11_data\",\"temperature\":%.1f,\"humidity\":%.1f,\"status\":\"ok\",\"timestamp\":%ld}",
                                g_temperature, g_humidity, (long)time(NULL));
                    } else {
                        // 读取失败，返回上次成功读取的数据和错误状态
                        snprintf(dht11_str, sizeof(dht11_str), 
                                "{\"type\":\"dht11_data\",\"temperature\":%.1f,\"humidity\":%.1f,\"status\":\"error\",\"timestamp\":%ld}",
                                g_temperature, g_humidity, (long)time(NULL));
                    }
                    
                    send(new_fd, dht11_str, strlen(dht11_str), 0);
                    printf("[TCP] 发送温湿度数据到客户端: %s\n", dht11_str);
                } else if (strstr(recvbuf, "GET_TIME") != NULL) {
                    // 客户端请求当前时间
                    time_t now;
                    struct tm *timeinfo;
                    
                    // 使用调整后的时间
                    now = get_adjusted_time(NULL);
                    timeinfo = localtime(&now);
                    
                    char time_str[128];
                    snprintf(time_str, sizeof(time_str), 
                            "{\"type\":\"time_data\",\"year\":%d,\"month\":%d,\"day\":%d,\"hour\":%d,\"min\":%d,\"sec\":%d,\"timestamp\":%ld}",
                            timeinfo->tm_year + 1900, timeinfo->tm_mon + 1, timeinfo->tm_mday,
                            timeinfo->tm_hour, timeinfo->tm_min, timeinfo->tm_sec, (long)now);
                    
                    send(new_fd, time_str, strlen(time_str), 0);
                    printf("[TCP] 发送当前时间到客户端: %s\n", time_str);
                } else if (strstr(recvbuf, "SET_AUTO_SEND") != NULL) {
                    // 设置自动发送间隔
                    char *interval_str = strstr(recvbuf, "interval");
                    if (interval_str != NULL) {
                        interval_str += strlen("interval");
                        while (*interval_str == ' ' || *interval_str == ':' || *interval_str == '"') {
                            interval_str++;
                        }
                        int interval = atoi(interval_str);
                        if (interval > 0) {
                            // 这里可以设置自动发送间隔，但目前固定为5秒
                            send(new_fd, "{\"type\":\"response\",\"message\":\"自动发送已设置\",\"interval\":5}", 59, 0);
                        } else {
                            send(new_fd, "{\"type\":\"response\",\"message\":\"无效的间隔值\"}", 46, 0);
                        }
                    }
                } else if (strstr(recvbuf, "FIND_DEVICE") != NULL) {
                    // 客户端请求查找设备，启动LED闪烁
                    char *speed_str = strstr(recvbuf, "\"speed\"");
                    int speed = 1; // 默认慢速闪烁
                    
                    if (speed_str != NULL) {
                        speed_str = strchr(speed_str, ':');
                        if (speed_str) {
                            speed_str++;
                            while (*speed_str == ' ' || *speed_str == '"') speed_str++;
                            speed = atoi(speed_str);
                            if (speed < 1 || speed > 3) speed = 1; // 确保速度值在有效范围内
                        }
                    }
                    
                    // 设置查找模式
                    g_findMode = 1;
                    g_findBlinkSpeed = speed;
                    
                    // 返回确认消息
                    char response[128];
                    snprintf(response, sizeof(response), 
                            "{\"type\":\"response\",\"message\":\"设备查找模式已启动\",\"find_mode\":1,\"speed\":%d}", 
                            g_findBlinkSpeed);
                    send(new_fd, response, strlen(response), 0);
                    
                    printf("[TCP] 启动设备查找模式，闪烁速度: %d\n", g_findBlinkSpeed);
                    
                    // 显示查找表情
                    SSD1306_DrawFace(FACE_SURPRISED);
                } else if (strstr(recvbuf, "STOP_FIND") != NULL) {
                    // 客户端请求停止查找
                    g_findMode = 0;
                    
                    // 返回确认消息
                    send(new_fd, "{\"type\":\"response\",\"message\":\"设备查找模式已停止\",\"find_mode\":0}", 62, 0);
                    
                    printf("[TCP] 停止设备查找模式\n");
                    
                    // 显示笑脸表情
                    SSD1306_DrawFace(FACE_SMILE);
                } else if (strstr(recvbuf, "\"year\"") != NULL && 
                          strstr(recvbuf, "\"month\"") != NULL && 
                          strstr(recvbuf, "\"day\"") != NULL && 
                          strstr(recvbuf, "\"hour\"") != NULL && 
                          strstr(recvbuf, "\"min\"") != NULL && 
                          strstr(recvbuf, "\"sec\"") != NULL) {
                    // 客户端发送了完整的时间信息，设置系统时间
            // 解析JSON格式的时间数据 
                    char *year_ptr = strstr(recvbuf, "\"year\"");
                    char *month_ptr = strstr(recvbuf, "\"month\"");
                    char *day_ptr = strstr(recvbuf, "\"day\"");
                    char *hour_ptr = strstr(recvbuf, "\"hour\"");
                    char *min_ptr = strstr(recvbuf, "\"min\"");
                    char *sec_ptr = strstr(recvbuf, "\"sec\"");
            
            if (year_ptr && month_ptr && day_ptr && hour_ptr && min_ptr && sec_ptr) {
                int year, month, day, hour, min, sec;
                
                        // 提取数值
                        year_ptr = strchr(year_ptr, ':');
                        month_ptr = strchr(month_ptr, ':');
                        day_ptr = strchr(day_ptr, ':');
                        hour_ptr = strchr(hour_ptr, ':');
                        min_ptr = strchr(min_ptr, ':');
                        sec_ptr = strchr(sec_ptr, ':');
                        
                        if (year_ptr && month_ptr && day_ptr && hour_ptr && min_ptr && sec_ptr) {
                            year_ptr++;  // 跳过冒号
                            month_ptr++;
                            day_ptr++;
                            hour_ptr++;
                            min_ptr++;
                            sec_ptr++;
                
                            // 跳过空格
                            while (*year_ptr == ' ') year_ptr++;
                            while (*month_ptr == ' ') month_ptr++;
                            while (*day_ptr == ' ') day_ptr++;
                            while (*hour_ptr == ' ') hour_ptr++;
                            while (*min_ptr == ' ') min_ptr++;
                            while (*sec_ptr == ' ') sec_ptr++;
                
                year = atoi(year_ptr);
                month = atoi(month_ptr);
                day = atoi(day_ptr);
                hour = atoi(hour_ptr);
                min = atoi(min_ptr);
                sec = atoi(sec_ptr);
                            
                            // 检查时间数据有效性
                            if (year >= 2000 && year <= 2099 && 
                                month >= 1 && month <= 12 && 
                                day >= 1 && day <= 31 && 
                                hour >= 0 && hour <= 23 && 
                                min >= 0 && min <= 59 && 
                                sec >= 0 && sec <= 59) {
                
                // 使用系统时间设置函数
                struct tm tm_time;
                tm_time.tm_year = year - 1900;  // 年份需要减去1900
                tm_time.tm_mon = month - 1;     // 月份从0开始
                tm_time.tm_mday = day;
                tm_time.tm_hour = hour;
                tm_time.tm_min = min;
                tm_time.tm_sec = sec;
                
                time_t timestamp = mktime(&tm_time);
                
                // 计算时间偏移量，而不是使用settimeofday
                time_t current_time;
                time(&current_time);
                g_time_offset = timestamp - current_time;
                
                printf("系统时间已成功设置为: %04d-%02d-%02d %02d:%02d:%02d\n", 
                      year, month, day, hour, min, sec);
                                      
                                // 返回JSON格式的成功响应
                                char response[128];
                                snprintf(response, sizeof(response), 
                                        "{\"type\":\"response\",\"message\":\"系统时间设置成功\",\"timestamp\":%ld}",
                                        (long)timestamp);
                                send(new_fd, response, strlen(response), 0);
                            } else {
                                // 时间数据无效
                                send(new_fd, "{\"type\":\"error\",\"message\":\"无效的时间数据\"}", 43, 0);
                                printf("收到无效的时间数据: %04d-%02d-%02d %02d:%02d:%02d\n", 
                                      year, month, day, hour, min, sec);
                            }
                        } else {
                            send(new_fd, "{\"type\":\"error\",\"message\":\"解析时间数据失败\"}", 45, 0);
                        }
                    }
                } else if (strstr(recvbuf, "\"hour\"") != NULL && 
                          strstr(recvbuf, "\"min\"") != NULL && 
                          strstr(recvbuf, "\"enable\"") != NULL) {
                    // 客户端发送了闹钟设置
                    char *hour_ptr = strstr(recvbuf, "\"hour\"");
                    char *min_ptr = strstr(recvbuf, "\"min\"");
                    char *enable_ptr = strstr(recvbuf, "\"enable\"");
                    char *alarm_id_ptr = strstr(recvbuf, "\"alarm_id\"");
                    int alarm_id = 1; // 默认为闹钟1
                    
                    if (alarm_id_ptr) {
                        alarm_id_ptr = strchr(alarm_id_ptr, ':');
                        if (alarm_id_ptr) {
                            alarm_id_ptr++;
                            while (*alarm_id_ptr == ' ' || *alarm_id_ptr == '"') alarm_id_ptr++;
                            alarm_id = atoi(alarm_id_ptr);
                        }
                    }
                    
                    if (hour_ptr && min_ptr && enable_ptr) {
                        int hour, min, enable;
                        
                        // 提取数值
                        hour_ptr = strchr(hour_ptr, ':');
                        min_ptr = strchr(min_ptr, ':');
                        enable_ptr = strchr(enable_ptr, ':');
                        
                        if (hour_ptr && min_ptr && enable_ptr) {
                            hour_ptr++;  // 跳过冒号
                            min_ptr++;
                            enable_ptr++;
                
                            // 跳过空格
                            while (*hour_ptr == ' ' || *hour_ptr == '"') hour_ptr++;
                            while (*min_ptr == ' ' || *min_ptr == '"') min_ptr++;
                            while (*enable_ptr == ' ' || *enable_ptr == '"') enable_ptr++;
                            
                            hour = atoi(hour_ptr);
                            min = atoi(min_ptr);
                            enable = atoi(enable_ptr);
                            
                            // 检查闹钟数据有效性
                            if (hour >= 0 && hour <= 23 && 
                                min >= 0 && min <= 59 && 
                                (enable == 0 || enable == 1)) {
                                
                                // 根据闹钟ID设置不同的闹钟
                                if (alarm_id == 1) {
                                    // 设置闹钟1
                                    g_ledHour = hour;
                                    g_ledMin = min;
                                    g_ledEnable = enable;
                                    
                                    printf("闹钟1设置成功 - 小时: %d, 分钟: %d, 使能状态: %d\n", 
                                          g_ledHour, g_ledMin, g_ledEnable);
                                } else if (alarm_id == 2) {
                                    // 设置闹钟2
                                    g_ledHour2 = hour;
                                    g_ledMin2 = min;
                                    g_ledEnable2 = enable;
                                    
                                    printf("闹钟2设置成功 - 小时: %d, 分钟: %d, 使能状态: %d\n", 
                                          g_ledHour2, g_ledMin2, g_ledEnable2);
            } else {
                                    // 无效的闹钟ID
                                    send(new_fd, "{\"type\":\"error\",\"message\":\"无效的闹钟ID，只支持1或2\"}", 52, 0);
                                    printf("收到无效的闹钟ID: %d\n", alarm_id);
                                    continue;
                                }
                                       
                                // 返回JSON格式的成功响应
                                char response[128];
                                snprintf(response, sizeof(response), 
                                        "{\"type\":\"response\",\"message\":\"闹钟%d设置成功\",\"alarm_id\":%d,\"hour\":%d,\"min\":%d,\"enable\":%d}",
                                        alarm_id, alarm_id, hour, min, enable);
                                send(new_fd, response, strlen(response), 0);
                            } else {
                                // 闹钟数据无效
                                send(new_fd, "{\"type\":\"error\",\"message\":\"无效的闹钟数据\"}", 43, 0);
            }
                        } else {
                            send(new_fd, "{\"type\":\"error\",\"message\":\"解析闹钟数据失败\"}", 45, 0);
                        }
                    }
                } else if (strstr(recvbuf, "GET_ALARMS") != NULL) {
                    // 客户端请求获取所有闹钟状态
                    char response[256];
                    snprintf(response, sizeof(response), 
                            "{\"type\":\"alarms_data\",\"alarms\":[{\"alarm_id\":1,\"hour\":%d,\"min\":%d,\"enable\":%d},{\"alarm_id\":2,\"hour\":%d,\"min\":%d,\"enable\":%d}]}",
                            g_ledHour, g_ledMin, g_ledEnable,
                            g_ledHour2, g_ledMin2, g_ledEnable2);
                    send(new_fd, response, strlen(response), 0);
                    printf("[TCP] 发送闹钟数据到客户端\n");
                } else if (strstr(recvbuf, "GET_FIND_STATUS") != NULL) {
                    // 客户端请求获取查找状态
                    char response[128];
                    snprintf(response, sizeof(response), 
                            "{\"type\":\"find_status\",\"find_mode\":%d,\"speed\":%d}",
                            g_findMode, g_findBlinkSpeed);
                    send(new_fd, response, strlen(response), 0);
                    printf("[TCP] 发送查找状态到客户端\n");
                } else {
                    // 其他请求，返回帮助信息
                    const char *help_msg = "{\"type\":\"help\",\"commands\":[\"GET_DHT11\",\"GET_TIME\",\"GET_ALARMS\",\"FIND_DEVICE\",\"STOP_FIND\",\"GET_FIND_STATUS\"],\"time_format\":{\"year\":2024,\"month\":6,\"day\":1,\"hour\":12,\"min\":0,\"sec\":0},\"alarm_format\":{\"alarm_id\":1,\"hour\":12,\"min\":0,\"enable\":1},\"find_format\":{\"speed\":1}}";
                    send(new_fd, help_msg, strlen(help_msg), 0);
        }
            }
            
            time_counter++;
        }
        
        close(new_fd);
        is_connected = 0;  // 重置连接状态
        printf("[TCP] 连接 %s:%d 已关闭\r\n", 
              inet_ntoa(client_sock.sin_addr),
              ntohs(client_sock.sin_port));
    }
}

static void TCPServerDemo(void)
{
    osThreadAttr_t attr;

    attr.name = "TCPServerTask";
    attr.attr_bits = 0U;
    attr.cb_mem = NULL;
    attr.cb_size = 0U;
    attr.stack_mem = NULL;
    attr.stack_size = TASK_STACK_SIZE;
    attr.priority = osPriorityNormal;

    if (osThreadNew((osThreadFunc_t)TCPServerTask, NULL, &attr) == NULL) {
        printf("[TCPServerDemo] Failed to create TCPServerTask!\n");
    }
}

// 同步时间函数(基于WiFi连接时间)
// 删除未使用的函数
    
    

// 修改led函数中的主控制循环
static void led(void) {
    printf("开始初始化GPIO...\n");
    
    // 初始化GPIO引脚
    if (IoTGpioInit(LED1_PIN) != 0) { // LED1
        printf("GPIO%d(LED1)初始化失败\n", LED1_PIN);
        return;
    }
    if (IoTGpioInit(LED2_PIN) != 0) {  // LED2
        printf("GPIO%d(LED2)初始化失败\n", LED2_PIN);
        return;
    }
    
    // 初始化SW-520D角度倾斜模块的GPIO引脚
    if (IoTGpioInit(SW520D_GPIO_PIN) != 0) {
        printf("GPIO%d(SW-520D)初始化失败\n", SW520D_GPIO_PIN);
        return;
    }
    
    // 配置LED引脚为输出
    if (IoTGpioSetDir(LED1_PIN, IOT_GPIO_DIR_OUT) != 0 || 
        IoTGpioSetDir(LED2_PIN, IOT_GPIO_DIR_OUT) != 0) {
        printf("LED GPIO方向设置失败\n");
        return;
    }
    
    // 配置蜂鸣器引脚为输出
    if (IoTGpioSetDir(BUZZER_PIN, IOT_GPIO_DIR_OUT) != 0) {
        printf("蜂鸣器GPIO方向设置失败\n");
        return;
    }
    
    // 配置SW-520D引脚为输入
    if (IoTGpioSetDir(SW520D_GPIO_PIN, IOT_GPIO_DIR_IN) != 0) {
        printf("SW-520D GPIO方向设置失败\n");
        return;
    }
    
    // 确保LED初始状态为关闭
    IoTGpioSetOutputVal(LED1_PIN, IOT_GPIO_VALUE1);
    IoTGpioSetOutputVal(LED2_PIN, IOT_GPIO_VALUE1);
    
    // 打印DHT11连接提示
    printf("\n");
    printf("===================== DHT11连接指南 =====================\n");
    printf("DHT11传感器需要正确连接才能工作：\n");
    printf("1. DHT11的VCC引脚连接到开发板的3.3V电源\n");
    printf("2. DHT11的GND引脚连接到开发板的GND\n");
    printf("3. DHT11的DATA引脚连接到GPIO%d\n", DHT11_GPIO_PIN);
    printf("4. DHT11的DATA引脚需要上拉电阻(4.7K-10K)连接到VCC\n");
    printf("5. 确保连接线缆长度不超过20cm，避免干扰\n");
    printf("========================================================\n\n");
    
    // 运行DHT11测试
    if (g_run_dht11_test) {
        printf("开始DHT11测试，将连续读取5次...\n");
        DHT11_Test(DHT11_GPIO_PIN, 5);
        g_run_dht11_test = 0;  // 测试完成后不再运行
    }
    
    // 初始化DHT11传感器
    printf("初始化DHT11温湿度传感器...\n");
    DHT11_Init(DHT11_GPIO_PIN);
    printf("DHT11初始化完成，等待稳定...\n");
    sleep(2); // 等待DHT11稳定
    
    // 初始化OLED显示屏
    printf("初始化OLED显示屏...\n");
    SSD1306_Init();
    
    // 显示开机表情 - 笑脸
    printf("尝试显示笑脸表情...\n");
    SSD1306_DrawFace(FACE_SMILE);
    printf("OLED显示笑脸完成\n");
    
    // 等待一段时间，确保显示稳定
    sleep(2);
    
    // 创建WiFi任务
    printf("启动WiFi任务...\n");
    WifiClientSTA();
    
    // 创建TCP服务任务
    printf("启动TCP服务任务...\n");
    TCPServerDemo();
    
    // 主循环
    int time_counter = 0;
    int alarm1_active = 0;      // 闹钟1激活标志
    int alarm1_duration = 0;    // 闹钟1持续时间计数（秒）
    int alarm2_active = 0;      // 闹钟2激活标志
    int alarm2_duration = 0;    // 闹钟2持续时间计数（秒）
    int last_sw520d_state = -1; // 上一次SW-520D的状态，用于检测状态变化
    int find_blink_counter = 0; // 查找模式闪烁计数器
    
    while (1) {
        // 获取当前时间
        time_t now = get_adjusted_time(NULL);
        struct tm *timeinfo = localtime(&now);
        
        // 读取SW-520D模块的状态
        IotGpioValue sw520d_state;
        if (IoTGpioGetInputVal(SW520D_GPIO_PIN, &sw520d_state) == 0) {
            // 状态发生变化时打印
            if (last_sw520d_state != sw520d_state) {
                if (sw520d_state == IOT_GPIO_VALUE0) {
                    printf("检测到盒子被打开\n");
                    // 盒子被打开时显示惊讶表情
                    SSD1306_DrawFace(FACE_SURPRISED);
                } else {
                    printf("检测到盒子被关闭\n");
                    // 盒子被关闭时显示中性表情
                    SSD1306_DrawFace(FACE_NEUTRAL);
                }
                last_sw520d_state = sw520d_state;
            }
        }
        
        // 每10秒读取一次DHT11温湿度数据（原来是5秒）
        if (time_counter % 10 == 0) {
            // 首次读取增加额外延迟，确保DHT11完全稳定
            if (g_first_dht11_read) {
                printf("首次DHT11读取，等待额外稳定时间...\n");
                sleep(3);
                g_first_dht11_read = 0;
            }
            
            printf("开始读取DHT11温湿度数据...\n");
            DHT11_Data_TypeDef dht11_data = DHT11_Read_Data(DHT11_GPIO_PIN);
            
            if (dht11_data.status == 0) {
                // 读取成功
                g_temperature = dht11_data.temperature;
                g_humidity = dht11_data.humidity;
                g_dht11_error_count = 0;
                
                // 打印温湿度数据
                printf("当前温度: %.1f℃, 湿度: %.1f%%\n", g_temperature, g_humidity);
                
                // 根据温度显示不同表情
                if (g_temperature > 30.0) {
                    // 温度过高，显示生气表情
                    SSD1306_DrawFace(FACE_ANGRY);
                } else if (g_temperature < 10.0) {
                    // 温度过低，显示惊讶表情
                    SSD1306_DrawFace(FACE_SURPRISED);
                }
            } else {
                // 读取失败
                g_dht11_error_count++;
                printf("DHT11读取失败，错误计数: %d\n", g_dht11_error_count);
                
                // 连续3次读取失败，重新初始化DHT11
                if (g_dht11_error_count >= 3) {
                    printf("尝试重新初始化DHT11...\n");
                    DHT11_Init(DHT11_GPIO_PIN);
                    g_dht11_error_count = 0;
                    
                    // 等待DHT11稳定
                    sleep(2);
                }
            }
        }
        
        // 每10秒输出一次当前时间
        if (time_counter % 10 == 0) {
            printf("当前时间: %04d-%02d-%02d %02d:%02d:%02d\n",
                  timeinfo->tm_year + 1900, timeinfo->tm_mon + 1, timeinfo->tm_mday,
                  timeinfo->tm_hour, timeinfo->tm_min, timeinfo->tm_sec);
        }
        
        // 处理查找模式 - 优先级最高
        if (g_findMode) {
            find_blink_counter++;
            
            // 根据闪烁速度设置不同的闪烁间隔
            int blink_interval;
            switch (g_findBlinkSpeed) {
                case 1:  // 慢速
                    blink_interval = 2;  // 每2秒闪烁一次
                    break;
                case 2:  // 中速
                    blink_interval = 1;  // 每1秒闪烁一次
                    break;
                case 3:  // 快速
                    blink_interval = 0;  // 每0.5秒闪烁一次（在下面处理）
                    break;
                default:
                    blink_interval = 1;
            }
            
            // 快速模式特殊处理
            if (g_findBlinkSpeed == 3) {
                // 每0.5秒切换一次LED状态
                if (find_blink_counter % 2 == 0) {
                    // 两个LED交替闪烁
                    if ((find_blink_counter / 2) % 2 == 0) {
                        IoTGpioSetOutputVal(LED1_PIN, IOT_GPIO_VALUE0); // LED1亮
                        IoTGpioSetOutputVal(LED2_PIN, IOT_GPIO_VALUE1); // LED2灭
                    } else {
                        IoTGpioSetOutputVal(LED1_PIN, IOT_GPIO_VALUE1); // LED1灭
                        IoTGpioSetOutputVal(LED2_PIN, IOT_GPIO_VALUE0); // LED2亮
                    }
                }
            } else {
                // 慢速和中速模式
                if (find_blink_counter % (blink_interval * 2) == 0) {
                    // 两个LED同时闪烁
                    IoTGpioSetOutputVal(LED1_PIN, IOT_GPIO_VALUE0); // LED1亮
                    IoTGpioSetOutputVal(LED2_PIN, IOT_GPIO_VALUE0); // LED2亮
                    
                    // 每次闪烁时短暂触发蜂鸣器
                    IoTGpioSetOutputVal(BUZZER_PIN, IOT_GPIO_VALUE1);
                } else if (find_blink_counter % blink_interval == 0) {
                    IoTGpioSetOutputVal(LED1_PIN, IOT_GPIO_VALUE1); // LED1灭
                    IoTGpioSetOutputVal(LED2_PIN, IOT_GPIO_VALUE1);  // LED2灭
                    
                    // 关闭蜂鸣器
                    IoTGpioSetOutputVal(BUZZER_PIN, IOT_GPIO_VALUE0);
                }
            }
            
            // 防止计数器溢出
            if (find_blink_counter >= 1000) {
                find_blink_counter = 0;
            }
        }
        // 检查闹钟1是否需要触发 - 查找模式下不触发闹钟
        else if (g_ledEnable && 
            timeinfo->tm_hour == g_ledHour && 
            timeinfo->tm_min == g_ledMin && 
            timeinfo->tm_sec == 0 && 
            !alarm1_active) {
            // 闹钟1时间到，开始闪烁LED
            printf("闹钟1时间到！开始闪烁LED灯...\n");
            alarm1_active = 1;
            alarm1_duration = 0;
            
            // 闹钟激活时显示生气表情
            SSD1306_DrawFace(FACE_ANGRY);
            
            // 激活蜂鸣器
            IoTGpioSetOutputVal(BUZZER_PIN, IOT_GPIO_VALUE1);
        }
        
        // 检查闹钟2是否需要触发 - 查找模式下不触发闹钟
        else if (g_ledEnable2 && 
            timeinfo->tm_hour == g_ledHour2 && 
            timeinfo->tm_min == g_ledMin2 && 
            timeinfo->tm_sec == 0 && 
            !alarm2_active && !alarm1_active) {  // 确保闹钟1未激活
            // 闹钟2时间到，开始闪烁LED
            printf("闹钟2时间到！开始闪烁LED灯...\n");
            alarm2_active = 1;
            alarm2_duration = 0;
            
            // 闹钟激活时显示惊讶表情
            SSD1306_DrawFace(FACE_SURPRISED);
            
            // 激活蜂鸣器（使用不同的模式）
            IoTGpioSetOutputVal(BUZZER_PIN, IOT_GPIO_VALUE1);
        }
        
        // 处理闹钟1激活状态 - 查找模式下不处理闹钟
        else if (alarm1_active) {
            // 如果盒子被打开（SW-520D输出低电平），则停止闹钟
            if (sw520d_state == IOT_GPIO_VALUE0) {
                printf("检测到盒子被打开，停止闹钟1\n");
                alarm1_active = 0;
                // 关闭LED和蜂鸣器
                IoTGpioSetOutputVal(LED1_PIN, IOT_GPIO_VALUE1);
                IoTGpioSetOutputVal(LED2_PIN, IOT_GPIO_VALUE1);
                IoTGpioSetOutputVal(BUZZER_PIN, IOT_GPIO_VALUE0);
                
                // 显示惊讶表情
                SSD1306_DrawFace(FACE_HEART);
            } else {
                // 闪烁LED灯（交替闪烁两个LED）- 闹钟1模式
                if (alarm1_duration % 2 == 0) {
                    IoTGpioSetOutputVal(LED1_PIN, IOT_GPIO_VALUE0); // LED1亮
                    IoTGpioSetOutputVal(LED2_PIN, IOT_GPIO_VALUE1);  // LED2灭
                    IoTGpioSetOutputVal(BUZZER_PIN, IOT_GPIO_VALUE1);  // 蜂鸣器开
                } else {
                    IoTGpioSetOutputVal(LED1_PIN, IOT_GPIO_VALUE1); // LED1灭
                    IoTGpioSetOutputVal(LED2_PIN, IOT_GPIO_VALUE0);  // LED2亮
                    IoTGpioSetOutputVal(BUZZER_PIN, IOT_GPIO_VALUE0);  // 蜂鸣器关
                }
                
                // 增加闹钟持续时间计数
                alarm1_duration++;
                
                // 闪烁2分钟后停止（2分钟 = 120秒）
                if (alarm1_duration >= 120) {
                    printf("闹钟1结束，LED停止闪烁\n");
                    alarm1_active = 0;
                    // 恢复LED和蜂鸣器状态为关闭
                    IoTGpioSetOutputVal(LED1_PIN, IOT_GPIO_VALUE1);
                    IoTGpioSetOutputVal(LED2_PIN, IOT_GPIO_VALUE1);
                    IoTGpioSetOutputVal(BUZZER_PIN, IOT_GPIO_VALUE0);
                    
                    // 显示睡觉表情
                    SSD1306_DrawFace(FACE_SLEEPY);
                }
            }
        }
        // 处理闹钟2激活状态 - 查找模式下不处理闹钟
        else if (alarm2_active) {
            // 如果盒子被打开（SW-520D输出低电平），则停止闹钟
            if (sw520d_state == IOT_GPIO_VALUE0) {
                printf("检测到盒子被打开，停止闹钟2\n");
                alarm2_active = 0;
                // 关闭LED和蜂鸣器
                IoTGpioSetOutputVal(LED1_PIN, IOT_GPIO_VALUE1);
                IoTGpioSetOutputVal(LED2_PIN, IOT_GPIO_VALUE1);
                IoTGpioSetOutputVal(BUZZER_PIN, IOT_GPIO_VALUE0);
                
                // 显示心形表情
                SSD1306_DrawFace(FACE_HEART);
            } else {
                // 闪烁LED灯 - 闹钟2模式（两个LED同时闪烁）
                if (alarm2_duration % 2 == 0) {
                    IoTGpioSetOutputVal(LED1_PIN, IOT_GPIO_VALUE0); // LED1亮
                    IoTGpioSetOutputVal(LED2_PIN, IOT_GPIO_VALUE0);  // LED2亮
                    IoTGpioSetOutputVal(BUZZER_PIN, IOT_GPIO_VALUE1);  // 蜂鸣器开
                } else {
                    IoTGpioSetOutputVal(LED1_PIN, IOT_GPIO_VALUE1); // LED1灭
                    IoTGpioSetOutputVal(LED2_PIN, IOT_GPIO_VALUE1);  // LED2灭
                    IoTGpioSetOutputVal(BUZZER_PIN, IOT_GPIO_VALUE0);  // 蜂鸣器关
                }
                
                // 增加闹钟持续时间计数
                alarm2_duration++;
                
                // 闪烁1分钟后停止（1分钟 = 60秒）
                if (alarm2_duration >= 60) {
                    printf("闹钟2结束，LED停止闪烁\n");
                    alarm2_active = 0;
                    // 恢复LED和蜂鸣器状态为关闭
                    IoTGpioSetOutputVal(LED1_PIN, IOT_GPIO_VALUE1);
                    IoTGpioSetOutputVal(LED2_PIN, IOT_GPIO_VALUE1);
                    IoTGpioSetOutputVal(BUZZER_PIN, IOT_GPIO_VALUE0);
                    
                    // 显示睡觉表情
                    SSD1306_DrawFace(FACE_SLEEPY);
                }
            }
        } else {
            // 非闹钟状态且非查找状态，保持LED和蜂鸣器关闭
            if (!g_findMode) {
                IoTGpioSetOutputVal(LED1_PIN, IOT_GPIO_VALUE1);
                IoTGpioSetOutputVal(LED2_PIN, IOT_GPIO_VALUE1);
                IoTGpioSetOutputVal(BUZZER_PIN, IOT_GPIO_VALUE0);
                
                // 每30秒更新一次表情，在中性、笑脸和心形之间切换
                // 但如果温度异常，则保持温度相关的表情
                if (time_counter % 30 == 0 && g_temperature >= 10.0 && g_temperature <= 30.0) {
                    int face_pattern = (time_counter / 30) % 3;
                    if (face_pattern == 0) {
                        SSD1306_DrawFace(FACE_NEUTRAL);
                    } else if (face_pattern == 1) {
                        SSD1306_DrawFace(FACE_SMILE);
                    } else {
                        SSD1306_DrawFace(FACE_HEART);
                    }
                }
            }
        }
        
        time_counter++;
        sleep(1); // 每秒检查一次时间
    }
}

// 添加自定义时间获取函数
static time_t get_adjusted_time(time_t *t) {
    time_t raw_time;
    time(&raw_time);
    
    // 应用时间偏移量
    time_t adjusted_time = raw_time + g_time_offset;
    
    if (t != NULL) {
        *t = adjusted_time;
    }
    
    return adjusted_time;
}

APP_FEATURE_INIT(led);